// pages/profile/user-profile.js
// 引入图表插件，需要先安装 wx-charts 或者使用原生 canvas 绘制
// 这里假设已经安装了 wx-charts
import wxCharts from "../../utils/wxcharts.js";

const app = getApp();

Page({
  /**
   * 页面的初始数据
   */
  data: {
    userInfo: {
      nickname: "",
      id: "",
      avatarUrl: "",
    },
    portraitData: {
      analysis: "",
      portrait: "",
      code: 0,
    },
    periodData: {
      morningHours: 0,
      afternoonHours: 0,
      eveningHours: 0,
      nightHours: 0,
    },
    loadingCharts: true,
    // 时间相关数据
    timeGranularity: ["年", "月", "日"],
    timeGranularityIndex: 1, // 默认选择"月"
    currentGranularity: "月",

    // 起始时间
    startYear: 2023,
    startMonth: 1,
    startDay: 1,

    // 结束时间
    endYear: 2023,
    endMonth: 12,
    endDay: 31,

    // 当前日期（用于设置默认值和限制选择范围）
    currentYear: 2023,
    currentMonth: 1,
    currentDay: 1,

    listeningData: {
      totalHours: 0,
    },
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    console.log("用户画像页面加载 onLoad");

    // 检查页面栈情况
    const pages = getCurrentPages();
    console.log(
      "当前页面栈:",
      pages.map((p) => p.route)
    );

    // 获取用户信息
    this.getUserInfo();

    // 获取当前日期
    const now = new Date();
    const currentYear = now.getFullYear();
    const currentMonth = now.getMonth() + 1;
    const currentDay = now.getDate();

    // 设置默认的时间范围（当前年份的1月1日到当前日期）
    this.setData({
      currentYear: currentYear,
      currentMonth: currentMonth,
      currentDay: currentDay,
      startYear: currentYear,
      startMonth: 1,
      startDay: 1,
      endYear: currentYear,
      endMonth: currentMonth,
      endDay: currentDay,
      listeningData: {
        totalHours: 0,
      },
    });

    // 获取用户画像数据
    this.fetchUserProfile();

    // 获取听歌时长
    this.fetchListeningDuration();

    // 根据默认时间范围获取数据
    this.fetchDataByTimeRange();
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    console.log("用户画像页面显示 onShow");
    // 检查是否可以返回上一页
    const pages = getCurrentPages();
    console.log(
      "onShow 当前页面栈:",
      pages.map((p) => p.route)
    );
    if (pages.length <= 1) {
      console.log("页面栈中只有一个页面，无法使用navigateBack返回");
    }
  },

  /**
   * 页面渲染完成后初始化图表
   */
  onReady: function () {
    // 页面渲染完成后，等待数据加载再初始化图表
    this.isPageReady = true;

    if (!this.data.loadingCharts) {
      console.log("onReady: 数据已加载完成，立即初始化图表");
      this.initCharts();
    } else {
      console.log("onReady: 数据加载中，等待数据加载完成后再初始化图表");
    }
  },

  /**
   * 获取用户信息
   */
  getUserInfo: function () {
    const userInfo = wx.getStorageSync("userInfo");
    if (userInfo) {
      this.setData({
        userInfo: {
          nickname: userInfo.nickname || userInfo.username || "用户",
          id: userInfo.userId || "",
          avatarUrl: userInfo.avatarUrl || "",
        },
      });
    }
  },

  /**
   * 获取用户画像
   */
  fetchUserProfile: function () {
    const userId = this.data.userInfo.id || "4"; // 默认使用ID为4，实际应使用用户真实ID

    wx.request({
      url: `${app.globalData.apiBaseUrl}/api/v1/user_profile`,
      method: "GET",
      data: {
        user_id: userId,
      },
      timeout: 30000, // 设置30秒超时
      success: (res) => {
        if (res.data && res.data.code === 0) {
          this.setData({
            portraitData: {
              analysis: res.data.analysis || "",
              portrait: res.data.portrait || "音乐爱好者",
              code: 0,
            },
          });
        } else {
          wx.showToast({
            title: "获取用户画像失败",
            icon: "none",
          });
        }
      },
      fail: (err) => {
        console.error("获取用户画像失败", err);
      },
    });
  },

  /**
   * 获取用户听歌时长
   */
  fetchListeningDuration: function () {
    const params = {
      user_id: this.data.userInfo.id || "4",
      year: this.data.endYear,
      month: this.data.endMonth,
      day: this.data.endDay,
    };

    wx.request({
      url: `${app.globalData.apiBaseUrl}/api/v1/listening_duration`,
      method: "GET",
      data: params,
      timeout: 15000, // 设置15秒超时
      success: (res) => {
        if (res.data && res.data.code === 0) {
          let totalHours = 0;

          if (res.data.data && res.data.data.length > 0) {
            // 修正计算逻辑：分钟转换为小时，需要除以60而不是乘以60
            totalHours =
              (res.data.data[0].total_duration / 3600).toFixed(1) || 0;
          }

          this.setData({
            "listeningData.totalHours": totalHours,
          });
        } else {
          console.log("未找到用户听歌时长数据", res.data.message);
          this.setData({
            "listeningData.totalHours": 0,
          });
        }
      },
      fail: (err) => {
        console.error("获取用户听歌时长失败", err);
        this.setData({
          "listeningData.totalHours": 0,
        });
      },
    });
  },

  /**
   * 根据时间粒度和范围获取对应的请求参数
   */
  getTimeRangeParams: function () {
    const granularityIndex = this.data.timeGranularityIndex;

    let params = {
      user_id: this.data.userInfo.id || "4",
      year: this.data.startYear,
    };

    // 根据时间粒度设置参数
    // 0: 年, 1: 月, 2: 日
    if (granularityIndex >= 1) {
      // 月或日
      params.month = this.data.startMonth;
    }

    if (granularityIndex >= 2) {
      // 日
      params.day = this.data.startDay;
    }

    return params;
  },

  /**
   * 根据选择的时间范围获取数据
   */
  fetchDataByTimeRange: function () {
    // 设置加载状态
    this.setData({
      loadingCharts: true,
    });

    // 计算开始和结束月份的总月数
    const startTotalMonths =
      this.data.startYear * 12 + this.data.startMonth - 1;
    const endTotalMonths = this.data.endYear * 12 + this.data.endMonth - 1;

    // 如果结束月份小于开始月份，显示错误提示
    if (endTotalMonths < startTotalMonths) {
      wx.showToast({
        title: "结束时间不能早于开始时间",
        icon: "none",
      });
      this.setData({
        loadingCharts: false,
      });
      return;
    }

    // 清空现有数据
    this.setData({
      periodData: {
        morningHours: 0,
        afternoonHours: 0,
        eveningHours: 0,
        nightHours: 0,
      },
    });

    // 创建月份请求队列
    let monthRequests = [];

    // 遍历所有需要查询的月份
    for (
      let totalMonth = startTotalMonths;
      totalMonth <= endTotalMonths;
      totalMonth++
    ) {
      const year = Math.floor(totalMonth / 12);
      const month = (totalMonth % 12) + 1;

      // 创建当前月份的请求参数
      const params = {
        user_id: this.data.userInfo.id || "4",
        year: year,
      };

      // 根据时间粒度设置参数
      // 0: 年, 1: 月, 2: 日
      if (this.data.timeGranularityIndex >= 1) {
        // 月或日
        params.month = month;
      }

      if (this.data.timeGranularityIndex >= 2) {
        // 日
        params.day = 1; // 默认使用每月第一天
      }

      monthRequests.push(params);
    }

    // 记录已完成的请求数量
    let completedRequests = 0;
    const totalRequests = monthRequests.length; // 每个月份有1个请求（时段）

    // 合并数据的辅助函数
    const mergeData = () => {
      completedRequests++;

      // 当所有请求完成后，更新加载状态并初始化图表
      if (completedRequests >= totalRequests) {
        this.setData({
          loadingCharts: false,
        });

        // 初始化图表
        if (this.isPageReady) {
          this.initCharts();
        }
      }
    };

    // 为每个月份发送请求
    monthRequests.forEach((params) => {
      // 获取用户听歌时段分布
      this.fetchPeriodStatsForMonth(params, mergeData);
    });
  },

  /**
   * 获取单个月份的用户听歌时段分布
   */
  fetchPeriodStatsForMonth: function (params, callback) {
    wx.request({
      url: `${app.globalData.apiBaseUrl}/api/v1/get_period_stats`,
      method: "GET",
      data: params,
      timeout: 15000, // 设置15秒超时
      success: (res) => {
        console.log("获取到的时段分布数据:", res.data);

        if (res.statusCode === 200 && res.data && res.data.code === 0) {
          // 获取当前数据
          let currentData = this.data.periodData;

          // 处理返回的数据
          if (res.data.data && res.data.data.length > 0) {
            const userData = res.data.data[0];

            // 如果有时段分布数据
            if (userData.period_distribution) {
              const distribution = userData.period_distribution;

              // 累加各时段数据（分钟）
              currentData.morningHours +=
                Math.round(distribution.morning / 60) || 0;
              currentData.afternoonHours +=
                Math.round(distribution.afternoon / 60) || 0;
              currentData.eveningHours +=
                Math.round(distribution.evening / 60) || 0;
              currentData.nightHours +=
                Math.round(distribution.night / 60) || 0;

              console.log("更新后的时段数据:", currentData);

              // 更新数据
              this.setData({
                periodData: currentData,
              });
            }
          }
        }

        // 调用回调函数
        if (callback) callback();
      },
      fail: (err) => {
        console.error("获取用户听歌时段分布失败", err);
        // 调用回调函数
        if (callback) callback();
      },
    });
  },

  /**
   * 查询按钮点击事件
   */
  handleQueryData: function () {
    // 设置加载状态
    this.setData({
      loadingCharts: true,
    });

    // 获取查询参数
    let params = this.getTimeRangeParams();

    // 获取听歌时长
    this.fetchListeningDuration();

    // 获取时段分布
    this.fetchPeriodStats(params);
  },

  /**
   * 时段选择器变化事件
   */
  bindTimeRangeChange: function (e) {
    const index = e.detail.value;
    if (index != this.data.timeRangeIndex) {
      this.fetchDataByTimeRange(index);
    }
  },

  /**
   * 获取用户听歌时段分布
   */
  fetchPeriodStats: function (params) {
    wx.request({
      url: `${app.globalData.apiBaseUrl}/api/v1/get_period_stats`,
      method: "GET",
      data: params,
      timeout: 15000, // 设置15秒超时
      success: (res) => {
        if (res.statusCode === 200 && res.data && res.data.code === 0) {
          let periodData = {
            morningHours: 0,
            afternoonHours: 0,
            eveningHours: 0,
            nightHours: 0,
          };

          // 处理返回的数据
          if (res.data.data && res.data.data.length > 0) {
            const userData = res.data.data[0];

            // 如果有时段分布数据
            if (userData.period_distribution) {
              const distribution = userData.period_distribution;

              // 将分钟转换为小时
              periodData = {
                morningHours: Math.round(distribution.morning / 60) || 0,
                afternoonHours: Math.round(distribution.afternoon / 60) || 0,
                eveningHours: Math.round(distribution.evening / 60) || 0,
                nightHours: Math.round(distribution.night / 60) || 0,
              };
            }
          } else {
            // 使用模拟数据（仅用于开发测试）
            periodData = {
              morningHours: 1,
              afternoonHours: 2,
              eveningHours: 2,
              nightHours: 1,
            };
          }

          this.setData({
            periodData: periodData,
            loadingCharts: false,
          });

          // 初始化图表
          if (this.isPageReady) {
            this.initCharts();
          }
        } else {
          console.error("获取用户听歌时段分布数据格式错误", res);
          this.setData({
            loadingCharts: false,
          });
        }
      },
      fail: (err) => {
        console.error("获取用户听歌时段分布失败", err);
        this.setData({
          loadingCharts: false,
        });
      },
    });
  },

  /**
   * 初始化图表
   */
  initCharts: function () {
    this.isPageReady = true;
    if (this.data.loadingCharts) return;

    console.log("初始化图表，使用的时段数据:", this.data.periodData);

    // 初始化听歌时段分布图表
    try {
      // 检查是否有有效数据
      const hasPeriodData =
        this.data.periodData.morningHours > 0 ||
        this.data.periodData.afternoonHours > 0 ||
        this.data.periodData.eveningHours > 0 ||
        this.data.periodData.nightHours > 0;

      // 如果没有数据，使用默认值
      const periodData = hasPeriodData
        ? this.data.periodData
        : {
            morningHours: 1,
            afternoonHours: 2,
            eveningHours: 2,
            nightHours: 1,
          };

      new wxCharts({
        canvasId: "periodDistributionChart",
        type: "pie",
        series: [
          {
            name: "上午 (6:00-12:00)",
            data: periodData.morningHours,
            color: "#5DADF9",
          },
          {
            name: "下午 (12:00-18:00)",
            data: periodData.afternoonHours,
            color: "#45D1C0",
          },
          {
            name: "晚上 (18:00-24:00)",
            data: periodData.eveningHours,
            color: "#935DF9",
          },
          {
            name: "深夜 (0:00-6:00)",
            data: periodData.nightHours,
            color: "#FF7676",
          },
        ],
        width: 320,
        height: 200,
        dataLabel: true,
        background: "#FFFFFF",
        animation: true,
        extra: {
          pie: {
            offsetAngle: -90,
            labelWidth: 15,
            borderWidth: 3,
            border: false,
          },
        },
      });
    } catch (error) {
      console.error("初始化听歌时段分布图表失败", error);
    }
  },

  /**
   * 生成随机颜色
   */
  getRandomColor: function () {
    const colors = [
      "#5DADF9",
      "#45D1C0",
      "#935DF9",
      "#FF7676",
      "#FFA45C",
      "#6694ff",
      "#53C7C0",
      "#7D3AC1",
      "#FF9F40",
      "#4CAF50",
      "#9C27B0",
      "#2196F3",
    ];
    return colors[Math.floor(Math.random() * colors.length)];
  },

  /**
   * 返回上一页
   */
  navigateBack: function () {
    console.log("返回按钮被点击");

    // 检查页面栈情况
    const pages = getCurrentPages();
    console.log(
      "点击返回时的页面栈:",
      pages.map((p) => p.route)
    );

    // 如果页面栈只有当前页面，直接跳转到首页
    if (pages.length <= 1) {
      console.log("页面栈只有当前页面，直接跳转到首页");
      this.navigateToHome();
      return;
    }

    // 显示加载状态，让用户知道按钮已被点击
    wx.showToast({
      title: "正在返回...",
      icon: "loading",
      duration: 500,
      mask: true,
    });

    // 尝试使用不同的方法返回
    try {
      // 方法1: 尝试使用navigateBack
      wx.navigateBack({
        delta: 1,
        fail: (err) => {
          console.error("navigateBack失败:", err);
          this.navigateToHome();
        },
      });
    } catch (error) {
      console.error("导航出错:", error);
      this.navigateToHome();
    }
  },

  /**
   * 导航到首页的备用方法
   */
  navigateToHome: function () {
    console.log("尝试导航到首页");

    wx.showToast({
      title: "正在跳转首页...",
      icon: "loading",
      duration: 500,
      mask: true,
    });

    // 尝试多种方式跳转到首页
    wx.switchTab({
      url: "/pages/home/home",
      success: function () {
        console.log("成功跳转到首页");
      },
      fail: function (switchErr) {
        console.error("switchTab失败:", switchErr);

        // 尝试使用reLaunch
        wx.reLaunch({
          url: "/pages/home/home",
          fail: function (relaunchErr) {
            console.error("reLaunch失败:", relaunchErr);

            // 最后尝试使用redirectTo
            wx.redirectTo({
              url: "/pages/home/home",
              fail: function (redirectErr) {
                console.error("所有导航方法都失败了");
                wx.showToast({
                  title: "返回失败",
                  icon: "none",
                });
              },
            });
          },
        });
      },
    });
  },

  /**
   * 时间粒度选择器变化事件
   */
  bindGranularityChange: function (e) {
    const index = e.detail.value;
    this.setData({
      timeGranularityIndex: index,
      currentGranularity: this.data.timeGranularity[index],
    });
  },

  /**
   * 起始年份选择器变化事件
   */
  bindStartYearChange: function (e) {
    this.setData({
      startYear: parseInt(e.detail.value) + 2020, // 假设年份范围从2020年开始
    });
  },

  /**
   * 起始月份选择器变化事件
   */
  bindStartMonthChange: function (e) {
    this.setData({
      startMonth: parseInt(e.detail.value) + 1,
    });
  },

  /**
   * 起始日期选择器变化事件
   */
  bindStartDayChange: function (e) {
    this.setData({
      startDay: parseInt(e.detail.value) + 1,
    });
  },

  /**
   * 结束年份选择器变化事件
   */
  bindEndYearChange: function (e) {
    this.setData({
      endYear: parseInt(e.detail.value) + 2020, // 假设年份范围从2020年开始
    });
  },

  /**
   * 结束月份选择器变化事件
   */
  bindEndMonthChange: function (e) {
    this.setData({
      endMonth: parseInt(e.detail.value) + 1,
    });
  },

  /**
   * 结束日期选择器变化事件
   */
  bindEndDayChange: function (e) {
    this.setData({
      endDay: parseInt(e.detail.value) + 1,
    });
  },

  /**
   * 直接跳转到"我的"页面
   */
  goToHome: function () {
    console.log("返回按钮点击，直接跳转到'我的'页面");

    // 显示加载提示
    wx.showLoading({
      title: "返回中...",
      mask: true,
    });

    // 直接跳转到"我的"页面，不尝试返回上一页
    wx.switchTab({
      url: "/pages/user/user",
      success: function () {
        console.log("成功跳转到'我的'页面");
        wx.hideLoading();
      },
      fail: function (err) {
        console.error("跳转到'我的'页面失败:", err);

        // 尝试使用navigateTo
        wx.navigateTo({
          url: "/pages/user/user",
          fail: function (navErr) {
            console.error("navigateTo失败:", navErr);
            wx.hideLoading();
            wx.showToast({
              title: "返回失败",
              icon: "none",
            });
          },
        });
      },
    });
  },
});
